 using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using NUnit.Framework;
using Studio7i.Dominio;
using Studio7i.Persistencia;
namespace Studio7i.Pruebas
{
    public class TestReservaDAO
    {

        [TestFixture]
        public class Test1_reservaDAO
        {
            // Atributos a utilizar durante las pruebas
            private ReservaDAO reservaDAO = null;
            private int codigoGenerado = 1;

           [TestFixtureSetUp]
           public void PrepararPruebas()
            {
               //1. Definimos la implementación del DAO a probar (ADO / NH / EF)
               reservaDAO = new Persistencia.ReservaDAO();

               // 2. Eliminamos todos los cientes en BD antes de las pruebas
               foreach (Reserva reserva in reservaDAO.ListarTodos())
                    reservaDAO.Eliminar(reserva);


               // 3. Creamos 2 reeservas para tenerlos disponibles en las pruebas
               Cliente cliente = new Cliente(1, "Dianita", "1234", "41763158", "Diana", "Deza Gabriel", "ddezag@gmail.com", DateTime.ParseExact("10-10-2011","dd-MM-yyyy",null));
               Local local = new Local(1, "Local A", "direccion1", "Lima");
               Sala sala = new Sala(1, "Sala1", 12, "caracteristicas1", "comentarios1", local);
               reservaDAO.Crear(new Reserva() { CodReserva = 1, FechReser =  DateTime.ParseExact("02-11-2011", "dd-MM-yyyy", null), Hora = 12, Tiempo = 2, Costo = 20, Cliente = cliente, Sala = sala, Local = local, Estado = 0 });

               Cliente cliente2 = new Cliente(2, "Cesitar", "1234", "87654321", "Cesar", "Deza Gabriel", "Cesar@gmail.com", DateTime.ParseExact("11-10-2011", "dd-MM-yyyy", null));
               Local local2 = new Local(2, "Local B","direccion2", "Lima");
               Sala sala2 = new Sala(2, "Sala2", 12, "caracteristicas2", "comentarios2", local2);
               reservaDAO.Crear(new Reserva() { CodReserva = 2, FechReser =DateTime.ParseExact("03-11-2011", "dd-MM-yyyy", null), Hora = 13, Tiempo = 3, Costo = 30, Cliente = cliente2, Sala = sala2, Local = local2, Estado = 0 });
             }


            [Test]
            public void Test1_Crear()
            {
                // 1. Clase a probar: ReservaDAO
                Assert.IsNotNull(reservaDAO);

                // 2. Declaramos e instanciamos la entidad de dominio
                Reserva reservaACrear = new Reserva();

                reservaACrear.FechReser = DateTime.ParseExact("04-11-2011", "dd-MM-yyyy", null);
                reservaACrear.Hora = 14;
                reservaACrear.Tiempo = 4;
                reservaACrear.Costo = 40;
                reservaACrear.Estado = 1;
                reservaACrear.Cliente = new Cliente();
                reservaACrear.Cliente.CodUser = 2;
                reservaACrear.Sala = new Sala();
                reservaACrear.Sala.CodSala = 1;
                reservaACrear.Local = new Local();
                reservaACrear.Local.CodLocal = 1;

                // 3. Declaramos la entidad que contendrá el resultado
                Reserva reservaCreada = new Reserva();
                reservaCreada.Cliente = new Cliente();
                reservaCreada.Sala = new Sala();
                reservaCreada.Local = new Local();

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    reservaCreada = reservaDAO.Crear(reservaACrear);
                   //codigoGenerado = reservaCreada.CodReserva;
                }, "reserva creaditaaaa");

                //// Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(reservaCreada);
                //// Probamos que el código generado sea mayor a 0
                Assert.Greater(reservaCreada.CodReserva, 0);
                //// Probamos que el nombre registrado es igual al solicitado con la entidad
                Assert.AreEqual(reservaCreada.Cliente.NombreUsuario, reservaACrear.Cliente.NombreUsuario);

            }

            [Test]
            public void Test2_Obtener()
            {
                // 1. Clase a probar: ReservaDAO
                Assert.IsNotNull(reservaDAO);
                // 2. Definimos los datos para la prueba
                int codigo = codigoGenerado;
                // 3. Declaramos la entidad que contendrá el resultado
                Reserva reservaObtenida = null;
                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    reservaObtenida = reservaDAO.Obtener(codigo);
                });

                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(reservaObtenida);
                Assert.AreEqual(reservaObtenida.CodReserva, codigo);
                Assert.Greater(reservaObtenida.Cliente.CodUser,0);
                
            }

            [Test]
            public void Test3_Modificar()
            {
                // 1. Clase a probar: ReservaDAO
                Assert.IsNotNull(reservaDAO);

                // 2. Declaramos e instanciamos la entidad de dominio a modificar
                Reserva reservaAModificar = new Reserva();
                reservaAModificar.CodReserva = 2;
                reservaAModificar.FechReser = DateTime.ParseExact("05-10-2011", "dd-MM-yyyy", null);
                reservaAModificar.Hora = 20;
                reservaAModificar.Tiempo = 2;
                reservaAModificar.Costo = 10;
                reservaAModificar.Cliente = new Cliente();
                reservaAModificar.Cliente.CodUser = 1;
                reservaAModificar.Sala = new Sala();
                reservaAModificar.Sala.CodSala = 1;
                reservaAModificar.Local = new Local();
                reservaAModificar.Local.CodLocal = 1;
                // 3. Declaramos la entidad que contendrá el resultado
                Reserva reservaModificada = null;

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    reservaModificada = reservaDAO.Modificar(reservaAModificar);
                }, "reserva modificado");
                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(reservaModificada);
                // Probamos que el código generado sea mayor a 0
                Assert.Greater(reservaModificada.CodReserva, 0);
                // Probamos que el nombre registrado es igual al solicitado con la entidad
                Assert.AreEqual(reservaModificada.Cliente.NombreUsuario, reservaAModificar.Cliente.NombreUsuario);

            }

            [Test]
            public void Test4_Eliminar()
            {
                // 1. Clase a probar: ReservaDAO
                Assert.IsNotNull(reservaDAO);

                // 2. Declaramos e instanciamos la entidad de dominio a eliminar
                codigoGenerado = 2;
                Reserva reservaAEliminar = reservaDAO.Obtener(codigoGenerado);

                // 3. Declaramos la entidad que contendrá el resultado
                Reserva reservaEliminada = null;

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    reservaDAO.Eliminar(reservaAEliminar);
                }, "reserva eliminado");

                // Probamos que la entidad resultante no sea nula
                Assert.IsNull(reservaEliminada);

            }

            [Test]
            public void Test5_ListarTodos()
            {
                // 1. Clase a probar: ReservaDAO
                Assert.IsNotNull(reservaDAO);

                // 2. Declaramos la entidad que contendrá el resultado
                ICollection<Reserva> reservasEncontradas= new List<Reserva>();

                // 3. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    reservasEncontradas= reservaDAO.ListarTodos();
                }, "Reservas Listadas");
                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(reservasEncontradas);
               
                // Probamos que cada Reserva contenga la cadena de búsqueda en su nombre
                foreach (Reserva reservaEncontrada in reservasEncontradas)
                {
                    Assert.IsNotNull(reservaEncontrada);
                    Assert.IsInstanceOf(typeof(Reserva), reservaEncontrada);
                }
            }
        }
    }
}